In `@protographic/src/abstract-selection-rewriter.ts`:
- Line 57: The currentType property is only set in the constructor and never
updated during AST traversal, so findNamedTypeForField always resolves against
the root type; update currentType as the visitor descends and ascends into
fields: when entering a field (or selection set) look up the field's type from
the previous currentType using the same logic as findNamedTypeForField and set
currentType to the named/unwrapped type, and when leaving the field restore the
previous currentType (e.g., push/pop or store parent type); modify the visitor
methods in the AbstractSelectionRewriter class that handle entering/leaving
fields/selections to maintain currentType correctly so nested selections resolve
to their actual object types.

In `@protographic/src/naming-conventions.ts`:
- Around line 88-110: The doc examples for createRequiredFieldsMethodName are
out of sync with createMethodSuffixFromEntityKey which sorts keys; update the
examples or remove the sort—prefer updating the examples: change the example
showing "name,id" to reflect the sorted suffix (i.e.,
createMethodSuffixFromEntityKey('name,id') => 'ByIdAndName' and
createRequiredFieldsMethodName('User','post','name,id') =>
'RequireUserPostByIdAndName'); reference createRequiredFieldsMethodName and
createMethodSuffixFromEntityKey when making the change.

In `@protographic/src/required-fields-visitor.ts`:
- Around line 496-519: The code in handleCompositeType overwrites
this.current.compositeType for each interface/union field so only the last
composite is kept; change the message model to hold an array (e.g.,
this.current.compositeTypes) and update handleCompositeType to push a new
composite metadata object instead of assigning to compositeType (use
CompositeMessageKind.INTERFACE/UNION, implementingTypes/memberTypes and typeName
as in the diff); also update any consumers/readers of current.compositeType to
iterate the new compositeTypes array (and adjust types/interfaces for the
message object accordingly).
- Around line 439-477: The nested message naming uses the object type name which
can collide when the same object type is used by multiple fields; update
onEnterSelectionSet to derive a unique nested message identifier (e.g., include
the parent field name or path) instead of solely using this.currentType.name,
then check this.current.nestedMessages for an existing nested by that identifier
and reuse it (push existing into stack and set this.current) instead of always
creating a new one; reference functions/vars to change: onEnterSelectionSet,
findObjectTypeForField / findObjectType, this.current, this.currentType,
this.current.nestedMessages, nested (ProtoMessage), this.stack, and
this.current.name to ensure no duplicate nested message definitions.
- Around line 141-152: The visitor currently iterates raw key directive strings
and emits duplicate RPC/messages when keys differ only by order/spacing; update
visit() to normalize and deduplicate key field sets (use the same normalization
that createRequiredFieldsMethodName uses or normalize by parsing, trimming and
sorting field names) by computing a normalizedKey (e.g., from
getKeyFieldsString(keyDirective) then normalize) and maintain a Set of
seenNormalizedKeys; if normalizedKey is already seen skip emitting (skip setting
this.mapping[this.currentKeyFieldsString] and calling visit(this.fieldSetDoc,
this.visitor)), otherwise add to seen and proceed, ensuring you still reference
this.currentKeyFieldsString/getKeyFieldsString and the mapping/visit calls when
emitting the first occurrence.

In `@protographic/src/sdl-validation-visitor.ts`:
- Around line 397-424: validateDisallowAbstractTypesForRequires currently calls
parse(fieldSelections.value) which can throw and abort validation; wrap the
parse call in a try/catch inside validateDisallowAbstractTypesForRequires, and
on parse failure convert the exception into a validation error via this.addError
(include parse error message and ctx.node.loc) instead of rethrowing; only
proceed to construct SelectionSetValidationVisitor, call visit(), and relay its
errors/warnings if parse succeeds.

In `@protographic/src/selection-set-validation-visitor.ts`:
- Around line 110-181: getFieldDefinition currently throws when a field isn't
found which aborts validation; change it to return null (or undefined) instead
and push a validation error into this.validationResult.errors (include field
name and this.currentType.name for context). Update the getFieldDefinition
signature to allow null and remove the throw; then update callers — onEnterField
and onEnterSelectionSet — to check the returned value (e.g., if (!fieldDef) {
return; } or push errors as needed) before using fieldDef.type or accessing
properties. Ensure error messages match existing validation style and keep
traversal/validation continuing instead of throwing.

In `@protographic/tests/field-set/01-basics.test.ts`:
- Around line 69-122: The test's `@requires` field set never contains duplicates
so the deduplication logic isn't exercised; update the SDL in this test (the sdl
string used to build the schema in the 'should visit a field set for a scalar
type and deduplicate fields' test) to include a duplicate selection (e.g. change
`@requires`(fields: "name") to `@requires`(fields: "name name") or otherwise repeat
"name") so RequiredFieldsVisitor receives a duplicated field in fieldSet and the
dedupe path is tested.

In `@protographic/src/abstract-selection-rewriter.ts`:
- Around line 122-142: The code replaces ctx.node.selections with
inlineFragments even when inlineFragments is empty, which drops interface-level
fields; add an early return (or skip the replacement) right after computing
inlineFragments (check inlineFragments.length === 0) to avoid mutating
ctx.node.selections when there are no inline fragments, then only proceed with
distributing fields into fragments (using fields, inlineFragments, this.hasField
and fragment.selectionSet.selections) when fragments exist.

In `@protographic/src/required-fields-visitor.ts`:
- Around line 445-494: The enter/leave imbalance happens because
onEnterSelectionSet sometimes returns before pushing, but onLeaveSelectionSet
always pops; fix by tracking whether a push happened and only pop when it did:
in onEnterSelectionSet compute a local pushed = false and set pushed = true
right before you push this.currentType onto this.ancestors and this.current onto
this.stack (and when you add nested message), then push that pushed flag onto a
new boolean stack (e.g., this.selectionSetPushStack) so the state is paired; in
onLeaveSelectionSet pop the flag from this.selectionSetPushStack and only pop
this.ancestors/this.stack and restore this.currentType/this.current when the
flag is true, leaving them unchanged when false. Ensure the new stack is
initialized on the class and used consistently with the existing ancestors/stack
fields.

In `@protographic/src/sdl-to-mapping-visitor.ts`:
- Around line 187-196: getRequiredFieldSet assumes the directive argument is a
StringValueNode and casts without checking, which yields undefined node.value
for non-string kinds; update getRequiredFieldSet to first inspect the directive
argument's kind (compare to Kind.STRING) before casting to StringValueNode,
throw a clear error when the argument is missing or not Kind.STRING, and ensure
Kind is imported from 'graphql' so the code safely accesses node.value for the
REQUIRES_DIRECTIVE_NAME lookup.

In `@protographic/src/selection-set-validation-visitor.ts`:
- Around line 110-115: When getFieldDefinition returns null in onEnterField,
return false (not undefined) so traversal into that field's subtree is skipped;
similarly, when onEnterSelectionSet cannot resolve the field/type, return false
instead of undefined. Update onEnterField (uses getFieldDefinition) and
onEnterSelectionSet to return false on failed lookups, and modify
onLeaveSelectionSet to only pop from the ancestors/currentType stacks when an
entry was actually pushed (e.g., check ancestors length or a pushed-flag) to
avoid corrupting currentType.
- Around line 110-123: The validator in SelectionSetValidationVisitor (methods
onEnterField and onEnterSelectionSet) wrongly rejects abstract types and inline
fragments for `@requires` field sets; remove or bypass the checks that call
isAbstractType(namedType) and that reject InlineFragment nodes so that abstract
return types (interfaces/unions) and inline fragments are allowed to pass
through to RequiredFieldsVisitor/AbstractSelectionRewriter for normalization.
Specifically, update onEnterField (remove the block that pushes the "Abstract
types are not allowed..." error and returns BREAK for abstract namedType) and
update onEnterSelectionSet (remove or guard the rejection of InlineFragment
nodes) — or alternatively wrap those checks so they are skipped when processing
`@requires` field sets handled by AbstractSelectionRewriter/RequiredFieldsVisitor.

In `@protographic/tests/field-set/01-basics.test.ts`:
- Around line 23-24: The docstring for the entityName field incorrectly claims a
default to the `@key` entity; update the comment for the entityName property (the
entityName field) to remove the "defaults to finding the type with `@key`
directive" phrase and clearly state that entityName is required (or,
alternatively, implement an actual fallback to derive entityName from the `@key`
directive in the code that constructs/validates entityName such as the
factory/parser that populates entityName); prefer the doc-only change: edit the
comment above the entityName declaration to indicate it is required and does not
default to `@key`.

In `@protographic/src/proto-utils.ts`:
- Around line 289-315: The JSDoc for createNestedListWrapper is incorrect: it
says the function returns the wrapper message name but the implementation
(createNestedListWrapper -> builds wrapperName and returns
buildWrapperMessage(...).join('\n')) actually returns the rendered proto message
string; update the `@returns` description to state it returns the generated
wrapper message definition as a string (e.g., the full proto message text), and
optionally mention that it uses buildWrapperMessage(includeComments,
wrapperName, level, baseType) to render it; keep references to
createNestedListWrapper, wrapperName, and buildWrapperMessage so future readers
can locate the logic.
- Around line 104-141: The oneof field numbers in buildCompositeTypeMessage are
assigned based on the original compositeTypes array order (from memberTypes or
implementingTypes) which is non-deterministic; before iterating, sort
compositeTypes deterministically (e.g., lexicographically by the type string) so
the loop that calls graphqlFieldToProtoField(compositeType) and assigns =
${index + 1} produces stable, repeatable field numbers and avoids
wire-compatibility breaks.
- Around line 149-171: The description can contain "/*" or "*/" which will break
the generated block comment; before trimming/splitting the description in
formatComment, sanitize the description string (e.g., replace "/*" with "/ *"
and "*/" with "* /" or another safe replacement) so the block opener/closer are
not present in the content, then proceed to compute lines and render single-line
(LINE_COMMENT_PREFIX) or multi-line (BLOCK_COMMENT_START/BLOCK_COMMENT_END)
comments as before; update formatComment to perform this replacement on the
description variable prior to using it.

In `@protographic/src/required-fields-visitor.ts`:
- Around line 133-138: The loop over this.keyDirectives is currently treating
every `@key` equally; update the iteration in required-fields-visitor (where
keyDirective is examined and getKeyFieldsString is called) to first inspect
keyDirective.arguments for an argument named "resolvable" and skip (continue) if
that argument exists and its value is the BooleanValue false, so non-resolvable
`@key` directives are not used to generate required-field RPCs; keep using
getKeyFieldsString, and throw the existing error only after confirming the
directive is resolvable.

In `@protographic/src/sdl-to-proto-visitor.ts`:
- Around line 1555-1564: The field-filtering logic in the Sdl-to-Proto visitor
is incorrectly excluding fields annotated with REQUIRES_DIRECTIVE_NAME; update
the filter that builds validFields (which currently uses
allFields.filter(...).filter(...)) to only exclude fields with the
EXTERNAL_DIRECTIVE_NAME (remove REQUIRES_DIRECTIVE_NAME from the directive
check), so fields with `@requires` remain included in the object message
generation (refer to variables allFields and validFields and the constants
EXTERNAL_DIRECTIVE_NAME and REQUIRES_DIRECTIVE_NAME to locate the code).

In `@protographic/src/proto-utils.ts`:
- Around line 60-77: Inside buildProtoMessageWithIndent the composite-type scope
currently reuses the parent seenTypes causing leaks; create a per-message scope
Set (e.g., messageSeenTypes = new Set<string>()) and use that instead of the
parent seenTypes when building composite types and when recursing into nested
messages (pass messageSeenTypes to buildCompositeTypeMessage and to recursive
buildProtoMessageWithIndent calls) so each message has its own composite-type
scope and the parent set is not mutated or leaked across siblings.